210db3184166372686e44a1f97fe53324493ec6d,inspections/impl/com/intellij/codeInspection/javaDoc/JavaDocLocalInspection.java,JavaDocLocalInspection,checkMethod,#PsiMethod#InspectionManager#boolean#,425

Before Change


      }
    }

     ArrayList<ProblemDescriptor> problems = null;

    final PsiDocTag tagByName = docComment.findTagByName("inheritDoc");
    if (tagByName != null) {
      final String tagName = tagByName.getName();
      final JavadocTagInfo tagInfo = tagByName.getManager().getJavadocManager().getTagInfo(tagName);
      if (tagInfo != null && tagInfo.isValidInContext(psiMethod)){
        return null;
      }
    }

    PsiDocTag[] tags = docComment.getTags();

    boolean isReturnRequired = false;
    boolean isReturnAbsent = true;
    if (superMethods.length == 0 && !psiMethod.isConstructor() && PsiType.VOID != psiMethod.getReturnType() && isTagRequired(psiMethod, "return")) {
      isReturnRequired = true;
      for (PsiDocTag tag : tags) {
        if ("return".equals(tag.getName())) {
          isReturnAbsent = false;
          break;
        }
      }
    }

    ArrayList<PsiParameter> absentParameters = null;
    if (superMethods.length == 0 && isTagRequired(psiMethod, "param") ) {
      PsiParameter[] params = psiMethod.getParameterList().getParameters();
      for (PsiParameter param : params) {
        boolean found = false;
        for (PsiDocTag tag : tags) {
          if ("param".equals(tag.getName())) {
            PsiDocTagValue value = tag.getValueElement();
            if (value instanceof PsiDocParamRef) {
              PsiDocParamRef paramRef = (PsiDocParamRef)value;
              if (paramRef.getReference().isReferenceTo(param)) {
                found = true;
                break;
              }
            }
          }
        }

        if (!found) {
          if (absentParameters == null) absentParameters = new ArrayList<PsiParameter>(2);
          absentParameters.add(param);
        }
      }
    }



    if (isReturnRequired && isReturnAbsent) {
      if (problems == null) {
        problems = new ArrayList<ProblemDescriptor>(2);
      }

      ProblemDescriptor descriptor = createMissingTagDescriptor(psiMethod.getNameIdentifier(), "return", manager);
      problems.add(descriptor);
    }

    if (absentParameters != null) {
      if (problems == null) problems = new ArrayList<ProblemDescriptor>(2);
      for (PsiParameter psiParameter : absentParameters) {
        ProblemDescriptor descriptor = createMissingParamTagDescriptor(psiMethod.getNameIdentifier(), psiParameter.getName(), manager);
        problems.add(descriptor);
      }
    }

    for (PsiDocTag tag : tags) {
      if ("param".equals(tag.getName())) {
        final PsiElement[] dataElements = tag.getDataElements();
        final PsiDocTagValue valueElement = tag.getValueElement();
        boolean hasProblemsWithTag = dataElements.length < 2;
        if (!hasProblemsWithTag) {
          final StringBuffer buf = new StringBuffer();
          for (PsiElement element : dataElements) {
            if (element != valueElement){
              buf.append(element.getText());
            }
          }
          hasProblemsWithTag = buf.toString().trim().length() == 0;
        }
        if (hasProblemsWithTag) {
          if (problems == null) problems = new ArrayList<ProblemDescriptor>(2);
          if (valueElement != null) {
            problems.add(createDescriptor(valueElement,
                                          InspectionsBundle.message("inspection.javadoc.method.problem.missing.tag.description", "<code>@param " + valueElement.getText() + "</code>"),
                                          manager));
          }

        }
      }
    }

    if (superMethods.length == 0 && isTagRequired(psiMethod, "@throws") && psiMethod.getThrowsList().getReferencedTypes().length > 0) {
      final Map<PsiClassType, PsiClass> declaredExceptions = new HashMap<PsiClassType, PsiClass>();
      final PsiClassType[] classTypes = psiMethod.getThrowsList().getReferencedTypes();
      for (PsiClassType classType : classTypes) {
        final PsiClass psiClass = classType.resolve();
        if (psiClass != null){
          declaredExceptions.put(classType, psiClass);
        }
      }
      processThrowsTags(tags, declaredExceptions);
      if (!declaredExceptions.isEmpty()) {
        if (problems == null) problems = new ArrayList<ProblemDescriptor>(2);
        for (PsiClassType declaredException : declaredExceptions.keySet()) {
          ProblemDescriptor descriptor = createMissingThrowsTagDescriptor(psiMethod, manager, declaredException);
          problems.add(descriptor);
        }
      }
    }

    ArrayList<ProblemDescriptor> tagProblems = getTagValuesProblems(psiMethod, tags, manager);
    if (tagProblems != null) {
      if (problems == null) problems = new ArrayList<ProblemDescriptor>(2);
      problems.addAll(tagProblems);
    }

    problems = checkForPeriodInDoc(docComment, problems, manager);

    for (PsiDocTag tag : tags) {
      if ("param".equals(tag.getName())) {
        if (extractTagDescription(tag).length() == 0) {
          PsiDocTagValue value = tag.getValueElement();
          if (value instanceof PsiDocParamRef) {
            PsiDocParamRef paramRef = (PsiDocParamRef)value;
            PsiParameter[] params = psiMethod.getParameterList().getParameters();
            for (PsiParameter param : params) {
              if (paramRef.getReference().isReferenceTo(param)) {
                if (problems == null) problems = new ArrayList<ProblemDescriptor>(2);
                problems.add(createDescriptor(value,
                                              InspectionsBundle.message("inspection.javadoc.method.problem.descriptor", "<code>@param</code>", "<code>" + param.getName() + "</code>"),
                                              manager));
              }
            }
          }
        }
      }
      else
        if ("return".equals(tag.getName())) {
          if (extractTagDescription(tag).length() == 0) {
            if (problems == null) problems = new ArrayList<ProblemDescriptor>(2);
            String message = InspectionsBundle.message("inspection.javadoc.method.problem.missing.tag.description", "<code>@return</code>");
            ProblemDescriptor descriptor = manager.createProblemDescriptor(tag, message, null, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, true);
            problems.add(descriptor);
          }
        }
    }

    problems = checkDuplicateTags(tags, problems, manager);

    return problems == null
           ? null
           : problems.toArray(new ProblemDescriptorImpl[problems.size()]);
  }

After Change


      problems.addAll(tagProblems);
    }

    checkForPeriodInDoc(docComment, problems, manager);

    for (PsiDocTag tag : tags) {
      if ("param".equals(tag.getName())) {
        if (extractTagDescription(tag).length() == 0) {
          PsiDocTagValue value = tag.getValueElement();
          if (value instanceof PsiDocParamRef) {
            PsiDocParamRef paramRef = (PsiDocParamRef)value;
            PsiParameter[] params = psiMethod.getParameterList().getParameters();
            for (PsiParameter param : params) {
              if (paramRef.getReference().isReferenceTo(param)) {
                problems.add(createDescriptor(value,
                                              InspectionsBundle.message("inspection.javadoc.method.problem.descriptor", "<code>@param</code>", "<code>" + param.getName() + "</code>"),
                                              manager));
              }
            }
          }
        }
      }
      else
        if ("return".equals(tag.getName())) {
          if (extractTagDescription(tag).length() == 0) {
            String message = InspectionsBundle.message("inspection.javadoc.method.problem.missing.tag.description", "<code>@return</code>");
            ProblemDescriptor descriptor = manager.createProblemDescriptor(tag, message, null, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, true);
            problems.add(descriptor);
          }
        }
    }

    checkDuplicateTags(tags, problems, manager);

    return problems.isEmpty()
           ? null
           : problems.toArray(new ProblemDescriptorImpl[problems.size()]);
  }